#include "Jeu.h"



Jeu::Jeu() {
	_listeTresor[0] = Tresor("Graal",NULL);
	_listeTresor[1] = Tresor("Dragon",NULL);
	_listeTresor[2] = Tresor("Spectre",NULL);
	_listeTresor[3] = Tresor("Hydre",NULL);
	_listeTresor[4] = Tresor("Coffre",NULL);
	_listeTresor[5] = Tresor("Lustre",NULL);
	_listeTresor[6] = Tresor("Rubis",NULL);
	_listeTresor[7] = Tresor("Cle",NULL);
	_listeTresor[8] = Tresor("Scarabee",NULL);
	_listeTresor[9] = Tresor("Statuette",NULL);
	_listeTresor[10] = Tresor("Lutin",NULL);
	_listeTresor[11] = Tresor("Diamant",NULL);
	_listeTresor[12] = Tresor("Saphir",NULL);
	_listeTresor[13] = Tresor("Emeraude",NULL);
	_listeTresor[14] = Tresor("Fantome",NULL);
	_listeTresor[15] = Tresor("Aspirine",NULL);
	_listeTresor[16] = Tresor("Manual",NULL);//RTFM !
	_listeTresor[17] = Tresor("Lunettes",NULL);
	_listeTresor[18] = Tresor("Or",NULL);
	_listeTresor[19] = Tresor("Argent",NULL);
	_listeTresor[20] = Tresor("Litiere",NULL);
	_listeTresor[21] = Tresor("Bouclier",NULL);
	_listeTresor[22] = Tresor("Lance",NULL);
	_listeTresor[23] = Tresor("Laser",NULL); 

	_plateau = Plateau(_listeTresor);
	_joueurs = vector<Joueur*>();
	_casesAccessiblesJoueur = vector<Case*>();
}




vector<Joueur*> Jeu::getJoueurs() {
	return _joueurs;
}

void Jeu::setRangeeCaseLibre(Rangee rg) {
	_plateau.setRangeeCaseLibre(rg);
}


Plateau* Jeu::getPlateau(){
	return &_plateau;
}

int Jeu::getJoueurCourant(){
	return _joueurCourant;
}

vector<vector<Case*> > Jeu::getCases() {
	return _plateau.getTable();
}

Case* Jeu::getCaseLibre() {
	return _plateau.getCaseLibre();
}

Rangee Jeu::getRangeeCaseLibre() {
	return _plateau.getRangeeCaseLibre();
}

vector<int> Jeu::getPosition(Joueur* player){
	vector<int> coord;
	bool absent = true;
	int i = 0;
	int j = 0;
	while(absent && i < 7){
		while( absent && j <7){
			if(_plateau.getCase(i,j)==player->getPosition()){
				absent = true;
				coord.push_back(i);
				coord.push_back(j);
			}
			j++;
		}
		j=0;
		i++;
	}
	return coord;
}
void Jeu::pivoterCaseLibre(int direction) {
	_plateau.pivoterCaseLibre(direction);
	notifie(false,true,false);
}

bool Jeu::insereCaseLibre() {
	_plateau.insereCaseLibre();
	Rangee rg = _plateau.getRangeeCaseLibre();
	int j,li,co;

	//Initialisation des coordonnées de la case qui vient
	//d'etre inseree
	if(rg.getEstLigne()){
		li=rg.getNumero();
		if(rg.getSens()) co=0;
		else co=6;
	}else{
		co=rg.getNumero();
		if(rg.getSens()) li=0;
		else li=6;
	}
	//Pour chaque joueur on regarde s'il est "hors jeu"
	//Et si oui on le replace
	for(j=0;j<(signed)_joueurs.size();j++){
		if(_joueurs[j]->getPosition() == _plateau.getCaseLibre()){
			_joueurs[j]->deplacerVersCase(_plateau.getCase(li,co));
		}
	}



	notifie(true,true,false);

	//on cacule les cases accessibles pour le joueur
	calculerCasesAccessibles();
	return !(_casesAccessiblesJoueur.empty());
}

vector<Case*> Jeu::casesAccessibles(const Case* depart) {
	return _casesAccessiblesJoueur;
}



void Jeu::initialiserPartie(int nbJoueur/*,int nbIA*/) {
	int myints[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23};
	vector<int> tresors (myints, myints + sizeof(myints) / sizeof(int) );

	_joueurs.push_back(new Humain(0,_plateau.getCase(0,0),tasTresor(&tresors,24/nbJoueur/*+nbIA*/)));
	if(nbJoueur>1)
		_joueurs.push_back(new Humain(1,_plateau.getCase(0,6),tasTresor(&tresors,24/nbJoueur/*+nbIA*/)));
	if(nbJoueur>2)
		_joueurs.push_back(new Humain(2,_plateau.getCase(6,0),tasTresor(&tresors,24/nbJoueur/*+nbIA*/)));
	if(nbJoueur>3)
		_joueurs.push_back(new Humain(3,_plateau.getCase(6,6),tasTresor(&tresors,24/nbJoueur/*+nbIA*/)));

	_joueurCourant=0;
	_finPartie=false;
	_casesAccessiblesJoueur = vector<Case*>();
	notifie(true,true,true);
}

vector<Tresor*> Jeu::tasTresor(vector<int>* vec, int nbTresor){
	vector<Tresor*> tas;
	srand(time(NULL));
	int aleatoire;
	int i = 0;
	while (i<nbTresor){
		aleatoire = rand()%vec->size();
		tas.push_back(&_listeTresor[vec->at(aleatoire)]);
		vec->erase(vec->begin()+aleatoire);
		i++;
	}
	return tas;
}

bool Jeu::deplacerJoueur( int  x, int  y){
	bool depEffectuee = false;
	if(coordonneesCorrectes(x,y)){
		_joueurs[_joueurCourant]->deplacerVersCase(_plateau.getCase(x,y));
		_finPartie=_joueurs[_joueurCourant]->gagne();
		depEffectuee = true;
		notifie(false,false,true);
	}
	return depEffectuee;
}

void Jeu::finTour( ){

	_joueurCourant=(_joueurCourant+1)%_joueurs.size();

	_casesAccessiblesJoueur=vector<Case*>();

}

bool Jeu::partieFinie(){

	return _finPartie;
}

bool Jeu::coordonneesCorrectes(int x, int y){
	return (_plateau.casePresente(_plateau.getCase(x,y), &_casesAccessiblesJoueur));
}

void Jeu::calculerCasesAccessibles(){
	_casesAccessiblesJoueur = _plateau.casesAccessibles(_joueurs[_joueurCourant]->getPosition());
}


